const db = require('../db/db')
const redis = require('../redis/redis')
const CONFIG = require('../config/config')
const {createToken} = require('../utils/tokenUtil')
const {encryption,decryption} = require('../utils/bcryptUtil')

class userService {
    // 查询用户是否存在
    async queryUser(ctx) {
        const { username } = ctx.request.body
        const [results] = await db.promise().query('select * from users where username=?', username, (error, results) => {
            if (error) {
                console.log(error.message);
                return
            }
        })
        if (results.length > 0) {
            return ctx.body = {
                code: 201,
                msg: '用户已存在'
            }
        } else {
            // 用户不存在，true代表可以往下继续注册
            return true
        }
    }
    // 注册用户
    async registerUser(ctx) {
        const { username, password } = ctx.request.body
        const bcryptPwd = await encryption(password)
        let create_time = new Date()
        let profile = CONFIG.DEFAULTAVATAR
        const params = [username, bcryptPwd, profile, create_time]
        const [results] = await db.promise().query('insert into users(username,password,profile,create_time) values(?,?,?,?)', params, (error, results) => {
            if (error) {
                console.log(error.message);
                return
            }
        })
        if (results.affectedRows > 0) {
            ctx.body = {
                code: 200,
                msg: '注册成功'
            }
        }
    }
    // 用户登录
    async userLogin(ctx){
        // 1.获取用户名密码
        const {username,password} = ctx.request.body
        // 2.查询用户是否存在
        const [results] = await db.promise().query('select * from users where username=?',username)
        if(results.length < 1){
           return ctx.body = {
                code:201,
                msg:'用户不存在'
            }
        }
        // 3.如果用户存在,查看密码是否正确
        // 拿到明文密码和加密后的密码进行比较
        const [userInfo] = await db.promise().query('select * from users where username=?',username)
        // newPwd是明文密码，oldPwd是加密后的密码
        const newPwd = password;
        const oldPwd = userInfo[0].password;
        // 两者对比
        const pwdIsTrue = await decryption(newPwd,oldPwd)
        // 如果返回true,代表密码正确，否者密码错误
        if(!pwdIsTrue){
            return ctx.body = {
                code:201,
                msg:"密码错误"
            }
        }
        // 4.用户密码正确了，就颁发一个token，返回200
        // 生成一个token存入redis的session
        let token = createToken()
        const sessionData = {
            id:userInfo[0].id,
            username,
            profile:userInfo[0].profile,
            identity:userInfo[0].identity,
            status:userInfo[0].status,
            token:token
        }
        const sessionDataIn = JSON.stringify(sessionData)
        redis.removeSession(ctx.header.authorization,'user')
        redis.setSession(token,'user',sessionDataIn)
        ctx.body = {
            code:200,
            msg:"登陆成功",
            data:sessionData
        }
    }
    // 获取用户信息
    async getUserInfo(ctx){
        const token = ctx.header.authorization
        const isExists = await redis.exists('session:'+token) 
        // 根据token查看redis是否存在该token,1存在，0不存在
        if(isExists == 1){
           await redis.getSession(token,'user').then(val => {
            const userInfo = JSON.parse(val)
            ctx.body = {
                code:1000,
                msg:'获取用户信息成功',
                userInfo
            }
           }).catch(err=>{
            console.log(err);
            ctx.body = {
                code:1002,
                msg:'获取用户信息失败',
            }
           })
        }else{
            ctx.body = {
                code:1001,
                msg:'token过期请重新登录',
                userInfo:''
            }
        }
    }
    // 退出登录
    async logout(ctx){
        const token = ctx.header.authorization
        // console.log(token);
        // // 摧毁token
        redis.removeSession(token,'user').then(res=>{
            ctx.body = {
                code:200,
                msg:'退出登录成功'
            }
        }).catch(err=>{
            ctx.body = {
                code:201,
                msg:'退出登录失败'+err
            }
        })
        
    }
    // 修改用户名
    async resetUsername(ctx){
        // 新名称和用户id
        const {username,id} = ctx.request.body
        const params = [username,id]
        await db.promise().query('update users set username=? where id=?', params).then( async res=>{
            if(res[0].affectedRows > 0){
                await db.promise().query('select * from users where id=?',id).then(res =>{
                    // 数据库修改用户名成功后，拿到token去修改redis里面的用户信息
                    ctx.body = {
                        code:200,
                        msg:'修改成功，请刷新',
                        userInfo:{
                            'id':res[0][0].id,
                            'username':res[0][0].username,
                            'profile':res[0][0].profile,
                            'token':'不给你看',
                            'identity':res[0][0].identity,
                        }
                    }

                })
            }
        }).catch(error=>{
            ctx.body = {
                code:200,
                msg:'修改失败'+error
            }
        })
        
        
    }
    // 修改密码
    async resetPwd(ctx){
        // 1.获取前端信息
        const { id, oldPwd, newPwd} = ctx.request.body
        // 2.利用id获取该用户信息
        const [[res]] = await db.promise().query('select password from users where id=?', id)
        // 3.取出旧密码
        const oldPwdRes = res.password
        // 4.对比旧密码和数据库的旧密码
        // 两者对比
        const pwdIsTrue = await decryption(oldPwd,oldPwdRes)
        if(pwdIsTrue){
        // 5.旧密码相比一样, 更新，新密码,新密码需要加密
        const newBcryptPwd = await encryption(newPwd)
        await db.promise().query('update users set password=? where id=?' , [newBcryptPwd,id]).then(res=>{
            if(res[0].affectedRows ==1){
                ctx.body = {
                    code:200,
                    msg:'修改成功,请重新登录'
                }
            }else{
                ctx.body = {
                    code:202,
                    msg:'修改错误'
                }
            }
        }).catch(error=>{
            ctx.body = {
                code:203,
                msg:error
            }
        })
        }else{
        // 6.旧密码相比不一样, 返回错误信息
            ctx.body = {
                code:201,
                msg:'原密码错误'
            }
        }
        
        
    }
    // 修改头像
    async resetAvatar(ctx){
        const {id, avatarUrl} = ctx.request.body
        const token = ctx.header.authorization
        if(avatarUrl == ''){
            ctx.body = {
                code:201,
                msg:'参数无效，请上传头像'
            }
            return
        }
        await db.promise().query('update users set profile=? where id=?',[avatarUrl,id]).then(async res=>{
            if(res[0].affectedRows ==1){
                const user= await redis.getSession(token,'user')
                const userObj = JSON.parse(user)
                userObj.profile = avatarUrl
                const userStr = JSON.stringify(userObj)
                redis.setSession(token,'user',userStr)
                ctx.body = {
                    code:200,
                    msg:'修改成功请刷新'
                }
            }else{
                ctx.body = {
                    code:202,
                    msg:'修改错误'
                }
            }
        }).catch(err=>{
            ctx.body = {
                code:201,
                msg:'未知错误'+err
            }
        })
    }

}
module.exports = new userService()